home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / terminal / term / extras / source / term-source.lha / CaptureParser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-26  |  10.6 KB  |  582 lines
  1. /*
  2. **    CaptureParser.c
  3. **
  4. **    Capture filter parser
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=8
  10. */
  11.  
  12. #include "termGlobal.h"
  13.  
  14. typedef BOOL (* SPECIAL_JUMP)(VOID);
  15. typedef BOOL (* __regargs ABORT_JUMP)(register WORD Char);
  16.  
  17. STATIC BOOL        SpecialBackspace(VOID);
  18. STATIC BOOL        SpecialReturn(VOID);
  19. STATIC BOOL        SpecialTab(VOID);
  20. STATIC BOOL        SpecialEsc(VOID);
  21. STATIC BOOL        SpecialCSI(VOID);
  22. STATIC BOOL        AbortCancel(VOID);
  23. STATIC BOOL        AbortEsc(VOID);
  24. STATIC BOOL        AbortCSI(VOID);
  25. STATIC BOOL __regargs    LocalParse(register WORD c);
  26.  
  27.     /* How many characters we will keep in the scan buffer. */
  28.  
  29. #define MAX_SCAN_SIZE    256
  30.  
  31. STATIC struct { UBYTE Key; SPECIAL_JUMP Routine; } LocalSpecialKeys[] =
  32. {
  33.     '\b',    (SPECIAL_JUMP)SpecialBackspace,    /* Erase a character. */
  34.     '\r',    (SPECIAL_JUMP)SpecialReturn,    /* Carriage return. */
  35.     '\t',    (SPECIAL_JUMP)SpecialTab,    /* Move to next tab stop. */
  36.     27,    (SPECIAL_JUMP)SpecialEsc,    /* Start new control sequence. */
  37.     155,    (SPECIAL_JUMP)SpecialCSI    /* Start new control sequence. */
  38. };
  39.  
  40. STATIC SPECIAL_JUMP    *LocalSpecialTable;
  41. STATIC ABORT_JUMP    *LocalAbortTable;
  42.  
  43. STATIC STRPTR        Arnie        = NULL;
  44. STATIC WORD        CharsInBuffer    = 0,
  45.             ScanStep    = 0;
  46. STATIC BOOL        LocalInSequence    = FALSE;
  47. STATIC UBYTE __far    SaveBuffer[MAX_SCAN_SIZE + 1];
  48.  
  49. STATIC UBYTE __far    LocalLineBuffer[BUFFER_LINE_MAX + 1];
  50. STATIC WORD        LocalLineLen,
  51.             LocalLineIndex;
  52.  
  53. STATIC BOOL
  54. SpecialBackspace()
  55. {
  56.     if(LocalLineIndex)
  57.         LocalLineIndex--;
  58.  
  59.     return(FALSE);
  60. }
  61.  
  62. STATIC BOOL
  63. SpecialReturn()
  64. {
  65.     LocalLineIndex = 0;
  66.  
  67.     return(FALSE);
  68. }
  69.  
  70. STATIC BOOL
  71. SpecialTab()
  72. {
  73.     WORD Index = (LocalLineIndex + 7) & ~8;
  74.  
  75.     if(Index > LocalLineLen)
  76.         memset(&LocalLineBuffer[LocalLineLen],' ',Index - LocalLineLen);
  77.  
  78.     LocalLineIndex = Index;
  79.  
  80.     if(Index > LocalLineLen)
  81.         LocalLineLen = Index;
  82.  
  83.     return(FALSE);
  84. }
  85.  
  86. STATIC BOOL
  87. SpecialEsc()
  88. {
  89.     return(TRUE);
  90. }
  91.  
  92. STATIC BOOL
  93. SpecialCSI()
  94. {
  95.     return(LocalParse('['));
  96. }
  97.  
  98. STATIC BOOL
  99. AbortCancel()
  100. {
  101.     LocalInSequence    = FALSE;
  102.     CharsInBuffer    = 0;
  103.     ScanStep    = 0;
  104.  
  105.     return(FALSE);
  106. }
  107.  
  108. STATIC BOOL
  109. AbortEsc()
  110. {
  111.     AbortCancel();
  112.  
  113.     LocalInSequence = TRUE;
  114.  
  115.     return(TRUE);
  116. }
  117.  
  118. STATIC BOOL
  119. AbortCSI()
  120. {
  121.     AbortCancel();
  122.  
  123.     LocalInSequence = TRUE;
  124.  
  125.     return(LocalParse('['));
  126. }
  127.  
  128.     /* LocalParse(UBYTE c):
  129.      *
  130.      *    Input:    A character to be passed through the ANSI code
  131.      *        parser.
  132.      *
  133.      *    Output:    FALSE if input characters did form a valid ANSI
  134.      *        control sequence or if input characters did not
  135.      *        form an ANSI control sequence at all.
  136.      *
  137.      *        TRUE if input characters did possibly introduce
  138.      *        a valid ANSI control sequence.
  139.      */
  140.  
  141. STATIC BOOL __regargs
  142. LocalParse(register WORD c)
  143. {
  144.         /* ScanStep = 0:    This is the first character
  145.          *            to introduce a control sequence.
  146.          */
  147.  
  148.     if(!ScanStep)
  149.     {
  150.         register WORD i;
  151.  
  152.             /* Scan all available codes and try to find
  153.              * a match.
  154.              */
  155.  
  156.         for(i = 0 ; i < NumCodes ; i++)
  157.         {
  158.                 /* This character may introduce a
  159.                  * control sequence.
  160.                  */
  161.  
  162.             if(ANSICode[i] . FirstChar == c)
  163.             {
  164.                     /* If this is a single
  165.                      * character control sequence
  166.                      * call the appropriate function
  167.                      * and exit immediately.
  168.                      */
  169.  
  170.                 if(ANSICode[i] . ExactSize == 1)
  171.                 {
  172.                     CharsInBuffer = ScanStep = 0;
  173.  
  174.                     return(FALSE);
  175.                 }
  176.                 else
  177.                 {
  178.                         /* The length of this control
  179.                          * sequence is greater than
  180.                          * a single character. Save
  181.                          * the input character and
  182.                          * return.
  183.                          */
  184.  
  185.                     ScanStep = i;
  186.  
  187.                     SaveBuffer[CharsInBuffer++] = c;
  188.  
  189.                         /* Where to stop. */
  190.  
  191.                     Arnie = ANSICode[i] . Terminator;
  192.  
  193.                     return(TRUE);
  194.                 }
  195.             }
  196.         }
  197.     }
  198.     else
  199.     {
  200.         if(CharsInBuffer < MAX_SCAN_SIZE)
  201.         {
  202.             if(Arnie)
  203.             {
  204.                 register WORD i;
  205.  
  206.                     /* Scan the remaining codes for a match. */
  207.  
  208.                 for(i = ScanStep ; i < NumCodes ; i++)
  209.                 {
  210.                         /* This sequence begins with the
  211.                          * same character the parser was
  212.                          * initialized with, so let's take
  213.                          * a look at it.
  214.                          */
  215.  
  216.                     if(ANSICode[i] . FirstChar == SaveBuffer[0])
  217.                     {
  218.                             /* This character is supposed to
  219.                              * terminate the sequence, so exit.
  220.                              */
  221.  
  222.                         if(Arnie[c])
  223.                         {
  224.                             CharsInBuffer = ScanStep = 0;
  225.  
  226.                             Arnie = NULL;
  227.  
  228.                             return(FALSE);
  229.                         }
  230.                         else
  231.                         {
  232.                                 /* If this character is part of
  233.                                  * a legal sequence store it
  234.                                  * and return.
  235.                                  */
  236.  
  237.                             if(ANSICode[i] . Match[c])
  238.                             {
  239.                                 ScanStep = i;
  240.  
  241.                                 SaveBuffer[CharsInBuffer++] = c;
  242.  
  243.                                 return(TRUE);
  244.                             }
  245.                         }
  246.                     }
  247.                 }
  248.             }
  249.             else
  250.             {
  251.                 register WORD i;
  252.  
  253.                 for(i = ScanStep ; i < NumCodes ; i++)
  254.                 {
  255.                         /* This sequence begins with the
  256.                          * same character the parser was
  257.                          * initialized with, so let's take
  258.                          * a look at it.
  259.                          */
  260.  
  261.                     if(ANSICode[i] . FirstChar == SaveBuffer[0])
  262.                     {
  263.                             /* This character is supposed to
  264.                              * terminate the sequence, so exit.
  265.                              */
  266.  
  267.                         if(ANSICode[i] . LastChar == c || (!ANSICode[i] . LastChar && CharsInBuffer == 2 && ANSICode[i] . ExactSize == 3))    // Special case for VT52
  268.                         {
  269.                             CharsInBuffer = ScanStep = 0;
  270.  
  271.                             return(FALSE);
  272.                         }
  273.                         else
  274.                         {
  275.                                 /* If this character is part of
  276.                                  * a legal sequence store it
  277.                                  * and return.
  278.                                  */
  279.  
  280.                             if(ANSICode[i] . Match[c])
  281.                             {
  282.                                 ScanStep = i;
  283.  
  284.                                 SaveBuffer[CharsInBuffer++] = c;
  285.  
  286.                                 return(TRUE);
  287.                             }
  288.                         }
  289.                     }
  290.                 }
  291.             }
  292.         }
  293.     }
  294.  
  295.         /* Return failure. */
  296.  
  297.     CharsInBuffer = ScanStep = 0;
  298.  
  299.     Arnie = NULL;
  300.  
  301.     return(FALSE);
  302. }
  303.  
  304. VOID
  305. CaptureParserExit()
  306. {
  307.     if(LocalSpecialTable)
  308.     {
  309.         FreeVecPooled(LocalSpecialTable);
  310.  
  311.         LocalSpecialTable = NULL;
  312.     }
  313.  
  314.     if(LocalAbortTable)
  315.     {
  316.         FreeVecPooled(LocalAbortTable);
  317.  
  318.         LocalAbortTable = NULL;
  319.     }
  320. }
  321.  
  322. BOOL
  323. CaptureParserInit()
  324. {
  325.     if(LocalSpecialTable = (SPECIAL_JUMP *)AllocVecPooled(256 * sizeof(SPECIAL_JUMP),MEMF_ANY | MEMF_CLEAR))
  326.     {
  327.         if(LocalAbortTable = (ABORT_JUMP *)AllocVecPooled(256 * sizeof(ABORT_JUMP),MEMF_ANY | MEMF_CLEAR))
  328.         {
  329.             WORD i;
  330.  
  331.             for(i = 0 ; i < NumElements(LocalSpecialKeys) ; i++)
  332.                 LocalSpecialTable[LocalSpecialKeys[i] . Key] = LocalSpecialKeys[i] . Routine;
  333.  
  334.             for(i = 0 ; i < 256 ; i++)
  335.             {
  336.                 switch(AbortMap[i])
  337.                 {
  338.                     case 0:    LocalAbortTable[i] = LocalParse;
  339.                         break;
  340.  
  341.                     case 1:    LocalAbortTable[i] = (ABORT_JUMP)AbortCancel;
  342.                         break;
  343.  
  344.                     case 2:    LocalAbortTable[i] = (ABORT_JUMP)AbortEsc;
  345.                         break;
  346.  
  347.                     case 3:    LocalAbortTable[i] = (ABORT_JUMP)AbortCSI;
  348.                         break;
  349.                 }
  350.             }
  351.  
  352.             return(TRUE);
  353.         }
  354.     }
  355.  
  356.     return(FALSE);
  357. }
  358.  
  359. VOID __regargs
  360. CaptureParser(register STRPTR Buffer,register LONG Size,register COPTR OutputRoutine)
  361. {
  362.     if(Size > 0)
  363.     {
  364.         register WORD c;
  365.  
  366.         if(Config -> SerialConfig -> StripBit8)
  367.         {
  368.             if(LocalInSequence)
  369.             {
  370.                 register BYTE Result;
  371.  
  372.                 do
  373.                 {
  374.                     c = *Buffer++ & 0x7F;
  375.  
  376.                     Result = (*LocalAbortTable[c])(c);
  377.                 }
  378.                 while(--Size > 0 && Result);
  379.  
  380.                 LocalInSequence = Result;
  381.             }
  382.  
  383.             if(Size > 0)
  384.             {
  385.                 register LONG BufferWidth = Config -> CaptureConfig -> BufferWidth - 1;
  386.  
  387.                 if(Config -> TerminalConfig -> FontMode == FONT_STANDARD)
  388.                 {
  389.                     do
  390.                     {
  391.                         c = (*Buffer++) & 0x7F;
  392.  
  393.                         if(LocalInSequence)
  394.                             LocalInSequence = (*LocalAbortTable[c])(c);
  395.                         else
  396.                         {
  397.                             if(LocalSpecialTable[c])
  398.                                 LocalInSequence = (*LocalSpecialTable[c])();
  399.                             else
  400.                             {
  401.                                 if(c == '\n' || c == '\f' || c == '\v')
  402.                                 {
  403.                                     (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  404.  
  405.                                     LocalLineIndex = LocalLineLen = 0;
  406.                                 }
  407.                                 else
  408.                                 {
  409.                                     if(IsGlyph[c])
  410.                                     {
  411.                                         LocalLineBuffer[LocalLineIndex++] = c;
  412.  
  413.                                         if(LocalLineIndex > LocalLineLen)
  414.                                             LocalLineLen = LocalLineIndex;
  415.  
  416.                                         if(LocalLineLen > BufferWidth)
  417.                                         {
  418.                                             (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  419.  
  420.                                             LocalLineIndex = LocalLineLen = 0;
  421.                                         }
  422.                                     }
  423.                                 }
  424.                             }
  425.                         }
  426.                     }
  427.                     while(--Size > 0);
  428.                 }
  429.                 else
  430.                 {
  431.                     do
  432.                     {
  433.                         c = (*Buffer++) & 0x7F;
  434.  
  435.                         if(LocalInSequence)
  436.                             LocalInSequence = (*LocalAbortTable[c])(c);
  437.                         else
  438.                         {
  439.                             if(LocalSpecialTable[c])
  440.                                 LocalInSequence = (*LocalSpecialTable[c])();
  441.                             else
  442.                             {
  443.                                 if(c == '\n' || c == '\f' || c == '\v')
  444.                                 {
  445.                                     (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  446.  
  447.                                     LocalLineIndex = LocalLineLen = 0;
  448.                                 }
  449.                                 else
  450.                                 {
  451.                                     if(c)
  452.                                     {
  453.                                         LocalLineBuffer[LocalLineIndex++] = c;
  454.  
  455.                                         if(LocalLineIndex > LocalLineLen)
  456.                                             LocalLineLen = LocalLineIndex;
  457.  
  458.                                         if(LocalLineLen > BufferWidth)
  459.                                         {
  460.                                             (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  461.  
  462.                                             LocalLineIndex = LocalLineLen = 0;
  463.                                         }
  464.                                     }
  465.                                 }
  466.                             }
  467.                         }
  468.                     }
  469.                     while(--Size > 0);
  470.                 }
  471.             }
  472.         }
  473.         else
  474.         {
  475.             if(LocalInSequence)
  476.             {
  477.                 register BYTE Result;
  478.  
  479.                 do
  480.                 {
  481.                     c = *Buffer++;
  482.  
  483.                     Result = (*LocalAbortTable[c])(c);
  484.                 }
  485.                 while(--Size > 0 && Result);
  486.  
  487.                 LocalInSequence = Result;
  488.             }
  489.  
  490.             if(Size > 0)
  491.             {
  492.                 register LONG BufferWidth = Config -> CaptureConfig -> BufferWidth - 1;
  493.  
  494.                 if(Config -> TerminalConfig -> FontMode == FONT_STANDARD)
  495.                 {
  496.                     do
  497.                     {
  498.                         c = *Buffer++;
  499.  
  500.                         if(LocalInSequence)
  501.                             LocalInSequence = (*LocalAbortTable[c])(c);
  502.                         else
  503.                         {
  504.                             if(LocalSpecialTable[c])
  505.                                 LocalInSequence = (*LocalSpecialTable[c])();
  506.                             else
  507.                             {
  508.                                 if(c == '\n' || c == '\f' || c == '\v')
  509.                                 {
  510.                                     (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  511.  
  512.                                     LocalLineIndex = LocalLineLen = 0;
  513.                                 }
  514.                                 else
  515.                                 {
  516.                                     if(IsGlyph[c])
  517.                                     {
  518.                                         LocalLineBuffer[LocalLineIndex++] = c;
  519.  
  520.                                         if(LocalLineIndex > LocalLineLen)
  521.                                             LocalLineLen = LocalLineIndex;
  522.  
  523.                                         if(LocalLineLen > BufferWidth)
  524.                                         {
  525.                                             (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  526.  
  527.                                             LocalLineIndex = LocalLineLen = 0;
  528.                                         }
  529.                                     }
  530.                                 }
  531.                             }
  532.                         }
  533.                     }
  534.                     while(--Size > 0);
  535.                 }
  536.                 else
  537.                 {
  538.                     do
  539.                     {
  540.                         c = *Buffer++;
  541.  
  542.                         if(LocalInSequence)
  543.                             LocalInSequence = (*LocalAbortTable[c])(c);
  544.                         else
  545.                         {
  546.                             if(LocalSpecialTable[c])
  547.                                 LocalInSequence = (*LocalSpecialTable[c])();
  548.                             else
  549.                             {
  550.                                 if(c == '\n' || c == '\f' || c == '\v')
  551.                                 {
  552.                                     (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  553.  
  554.                                     LocalLineIndex = LocalLineLen = 0;
  555.                                 }
  556.                                 else
  557.                                 {
  558.                                     if(c)
  559.                                     {
  560.                                         LocalLineBuffer[LocalLineIndex++] = c;
  561.  
  562.                                         if(LocalLineIndex > LocalLineLen)
  563.                                             LocalLineLen = LocalLineIndex;
  564.  
  565.                                         if(LocalLineLen > BufferWidth)
  566.                                         {
  567.                                             (*OutputRoutine)(LocalLineBuffer,LocalLineLen);
  568.  
  569.                                             LocalLineIndex = LocalLineLen = 0;
  570.                                         }
  571.                                     }
  572.                                 }
  573.                             }
  574.                         }
  575.                     }
  576.                     while(--Size > 0);
  577.                 }
  578.             }
  579.         }
  580.     }
  581. }
  582.